{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26fdca1c",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1f12280f",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ab106c82",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = '../Dataset/CIFAR10'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4721c3cb",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d42765cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.331518\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6f88764e",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ When W is nearly a zero matrix, loss = -log(1/number of classes). Here number of classes=10 hence loss = -log(0.1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4c2626ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -0.666241 analytic: -0.666241, relative error: 7.698828e-08\n",
      "numerical: -1.629500 analytic: -1.629500, relative error: 4.928843e-09\n",
      "numerical: 0.056630 analytic: 0.056630, relative error: 7.220199e-07\n",
      "numerical: -0.123823 analytic: -0.123823, relative error: 2.389322e-07\n",
      "numerical: -1.968071 analytic: -1.968071, relative error: 9.635753e-09\n",
      "numerical: 0.559121 analytic: 0.559121, relative error: 1.197578e-07\n",
      "numerical: 0.510365 analytic: 0.510365, relative error: 1.578199e-07\n",
      "numerical: -2.494595 analytic: -2.494595, relative error: 5.274717e-10\n",
      "numerical: 1.149846 analytic: 1.149846, relative error: 3.681162e-08\n",
      "numerical: -4.562950 analytic: -4.562950, relative error: 6.430017e-09\n",
      "numerical: -2.587942 analytic: -2.587942, relative error: 1.146656e-08\n",
      "numerical: 0.917536 analytic: 0.917536, relative error: 2.398469e-08\n",
      "numerical: -0.842541 analytic: -0.842541, relative error: 3.920502e-08\n",
      "numerical: 2.103529 analytic: 2.103529, relative error: 2.645292e-08\n",
      "numerical: 2.920980 analytic: 2.920980, relative error: 2.665670e-10\n",
      "numerical: 0.575065 analytic: 0.575065, relative error: 5.356818e-08\n",
      "numerical: 4.839165 analytic: 4.839165, relative error: 7.888032e-10\n",
      "numerical: -0.477114 analytic: -0.477114, relative error: 1.868096e-08\n",
      "numerical: 0.891215 analytic: 0.891215, relative error: 4.604284e-09\n",
      "numerical: 3.320977 analytic: 3.320977, relative error: 1.696004e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "434e757f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.331518e+00 computed in 0.534906s\n",
      "vectorized loss: 2.331518e+00 computed in 0.033189s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2e5e374d",
   "metadata": {
    "tags": [
     "code"
    ],
    "test": "tuning"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 382.703825\n",
      "iteration 100 / 1500: loss 2.293936\n",
      "iteration 200 / 1500: loss 2.295500\n",
      "iteration 300 / 1500: loss 2.294397\n",
      "iteration 400 / 1500: loss 2.293655\n",
      "iteration 500 / 1500: loss 2.293789\n",
      "iteration 600 / 1500: loss 2.292343\n",
      "iteration 700 / 1500: loss 2.295186\n",
      "iteration 800 / 1500: loss 2.292255\n",
      "iteration 900 / 1500: loss 2.293411\n",
      "iteration 1000 / 1500: loss 2.293801\n",
      "iteration 1100 / 1500: loss 2.292959\n",
      "iteration 1200 / 1500: loss 2.292156\n",
      "iteration 1300 / 1500: loss 2.292892\n",
      "iteration 1400 / 1500: loss 2.288475\n",
      "iteration 0 / 1500: loss 783.068890\n",
      "iteration 100 / 1500: loss 2.294045\n",
      "iteration 200 / 1500: loss 2.290126\n",
      "iteration 300 / 1500: loss 2.294615\n",
      "iteration 400 / 1500: loss 2.294831\n",
      "iteration 500 / 1500: loss 2.294818\n",
      "iteration 600 / 1500: loss 2.296840\n",
      "iteration 700 / 1500: loss 2.297151\n",
      "iteration 800 / 1500: loss 2.294927\n",
      "iteration 900 / 1500: loss 2.296451\n",
      "iteration 1000 / 1500: loss 2.293831\n",
      "iteration 1100 / 1500: loss 2.294414\n",
      "iteration 1200 / 1500: loss 2.295989\n",
      "iteration 1300 / 1500: loss 2.296530\n",
      "iteration 1400 / 1500: loss 2.296828\n",
      "iteration 0 / 1500: loss 387.720895\n",
      "iteration 100 / 1500: loss 2.280083\n",
      "iteration 200 / 1500: loss 2.267616\n",
      "iteration 300 / 1500: loss 2.266258\n",
      "iteration 400 / 1500: loss 2.265015\n",
      "iteration 500 / 1500: loss 2.270140\n",
      "iteration 600 / 1500: loss 2.255929\n",
      "iteration 700 / 1500: loss 2.258578\n",
      "iteration 800 / 1500: loss 2.268456\n",
      "iteration 900 / 1500: loss 2.272233\n",
      "iteration 1000 / 1500: loss 2.270800\n",
      "iteration 1100 / 1500: loss 2.278276\n",
      "iteration 1200 / 1500: loss 2.279198\n",
      "iteration 1300 / 1500: loss 2.254456\n",
      "iteration 1400 / 1500: loss 2.266247\n",
      "iteration 0 / 1500: loss 765.509457\n",
      "iteration 100 / 1500: loss 2.255139\n",
      "iteration 200 / 1500: loss 2.271949\n",
      "iteration 300 / 1500: loss 2.274505\n",
      "iteration 400 / 1500: loss 2.257600\n",
      "iteration 500 / 1500: loss 2.266759\n",
      "iteration 600 / 1500: loss 2.267541\n",
      "iteration 700 / 1500: loss 2.264971\n",
      "iteration 800 / 1500: loss 2.251983\n",
      "iteration 900 / 1500: loss 2.270772\n",
      "iteration 1000 / 1500: loss 2.267088\n",
      "iteration 1100 / 1500: loss 2.261208\n",
      "iteration 1200 / 1500: loss 2.274511\n",
      "iteration 1300 / 1500: loss 2.281285\n",
      "iteration 1400 / 1500: loss 2.258662\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.225939 val accuracy: 0.218000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.210408 val accuracy: 0.215000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.229551 val accuracy: 0.221000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.200776 val accuracy: 0.206000\n",
      "best validation accuracy achieved during cross-validation: 0.221000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates: \n",
    "    for reg in regularization_strengths: \n",
    "        clf = Softmax() \n",
    "        loss_hist = clf.train(X_train, y_train, learning_rate=lr, reg=reg, \n",
    "                              num_iters=1500, verbose=True \n",
    "                              ) \n",
    "        y_train_pred = clf.predict(X_train) \n",
    "        y_val_pred = clf.predict(X_val) \n",
    "        train_acc = np.mean(y_train == y_train_pred) \n",
    "        val_acc = np.mean(y_val == y_val_pred) \n",
    "        results[(lr, reg)] = train_acc, val_acc \n",
    "        if val_acc > best_val: \n",
    "            best_softmax = clf \n",
    "            best_val = val_acc \n",
    "\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "deb37cc6",
   "metadata": {
    "test": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.237000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "df501314",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ True \n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$ svm loss depends on the relative score and if the score of the added datapoint is 1(margin) less than the correct score then the total loss remains unchanged whereas in softmax every datapoint has some contribution in the total loss.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ade33adc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d5d17f8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
